[Music]
Welcome to Microservices with OpenShift. After watching this video, you'll be able to Describe how OpenShift makes
developers lives easier, Explain the process by which
microservices are deployed on OpenShift. Watch Si Vennam from the IBM Cloud team describe
how to deploy microservices with OpenShift. We'll start with developers. So we'll sketch out a developer up here. Now what does a developer have to do? Well, they generally have to write
applications, create changes, test them out, deploy them into a cluster, and
they're really just focused on that and any other kind of distractions
will slow them down from that task. So, with dev, the first thing
that they're going to want to do when starting with OpenShift is to
create a project and an application. To do so, OpenShift has two different ways of
enabling developers to work with their platform. So, one you can take advantage of the CLI, and there's also a really powerful web
console that they could work with as well. So, the first thing that the dev wants to do is take advantage of one of those two form
factors to create a project and an application. And there's templates for all
different kinds of source code and programming languages that
the dev wants to work with. So, they'll go ahead and do that and then, you know, once they get into their flow
of creating updates to an application, the very first step they're going to want
to do is push changes to a repository. And in this case, let's use GitHub as an example. Let's say that this developer
is making changes into GitHub. That's really all they need to do. Behind the scenes, OpenShift is
going to take care of the rest. So, when that application and project was created,
OpenShift in the back end will create a jenkins job and pipeline that helps
power deploying this application. So, once code gets pushed into that GitHub, it'll
trigger a web hook, which kicks off a Jenkins job. Which is just going to do two things: First, what it's going to do is do
something called source to image, which is going to create a docker
image out of that source code. Next, it's going to go ahead and
take that and put it into a registry. A private registry, which comes built-in
in OpenShift and, in fact, you can actually use public registries or your own registry if
you have it outside of this context as well. Once that image gets built
and pushed into that registry next, what OpenShift will do is go ahead
and push that into the actual cluster. And that's what we've got here is two
hosts that are in our cluster in OpenShift. We're gonna take that image and let's say
that we've set it up to deploy two times. And we'll call this v1 of the application. So, let's kind of overview
that process one more time. So, the developer makes some change to a code
then Jenkins will kind of kick off that build, create an image, push that image to a registry, and then a little bit of a different thing here, So, in this step right here, OpenShift takes
advantage of something called image streams, which is a little bit different to how
Kubernetes will do things and essentially what it enables you to do is whenever a
change is kind of detected with that image, an image stream will allow you to push
those with no downtime to your applications. So, what it'll do is, you know, with that new
version of that code, it'll bring down the old version, start the new version until we've rolled
out the whole new version of that application. This is just a few ways that OpenShift
makes developers' lives easier. In this video, you learned that
OpenShift creates a Jenkins job to automatically build
microservices into containers, OpenShift pushes the built
containers to a registry and deploys those containers to the cluster